// pages/proposal/detail.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    showFullContent: false,
    showResultContent: false,
    opinions: {},
    signersStr: "",// 用于存储处理后的字符串
    hasResponded: false, // 是否已响应
    responseType: '', // 响应类型：'拒绝' 或 '同意'
    downloadedFiles: null,
    currentShareFile: null,
  },

  // 计算当前显示状态
  computeDisplayStatus(opinions) {
    if (!opinions) return '';

    // 首先判断isOr的状态
    if (opinions.isOr === null) {
      return '处理中';
    } else if (opinions.isOr === false) {
      return '联名失败';
    }

    // 当isOr为true时，显示正常的状态流程
    if (!opinions.status) return '';

    const status = opinions.status;

    // 根据不同状态返回对应的显示文本
    switch (status) {
      case '处理中':
        return '报送初审';
      case '初审':
        if (opinions.firstAuditTime && !opinions.recheckTime) {
          return '复审';
        }
        return '初审';
      case '复审':
        if (opinions.recheckTime && !opinions.shuntTime) {
          return '分流处理';
        }
        return '复审';
      case '分流':
        if (opinions.shuntTime && !opinions.specialHandlingTime) {
          return '专项处理';
        }
        return '分流处理';
      case '专项处理':
        if (opinions.specialHandlingTime && !opinions.finalReplyTime) {
          return '最终批复';
        }
        return '专项处理';
      case '最终批复':
        if (opinions.finalReplyTime && !opinions.completionTime) {
          return '处理完结';
        }
        return '最终批复';
      case '已驳回':
        return '已驳回';
      default:
        return status;
    }
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log(options)
    // 初始化数据
    this.getProposalDetail(options.item).then(
      res => {
        // 计算显示状态
        const displayStatus = this.computeDisplayStatus(res);

        this.setData({
          opinions: res,
          displayStatus: displayStatus // 添加显示状态到数据中
        });
        // 处理联名人数据（如果是异步接口，在回调中处理）
        this.processSignersName();
        const opinionId = this.data.opinions.opinionId
        const cachedFiles = wx.getStorageSync(`downloaded_files_civil_${opinionId}`)
        if (cachedFiles && Array.isArray(cachedFiles) && cachedFiles.length > 0 && cachedFiles.length === 
        (this.data.opinions.attachments?this.data.opinions.attachments.length+1:1)) {
          // 验证文件是否仍然存在
          this.validateCachedFiles(cachedFiles, opinionId);
        }
      }
    )
  },
  processSignersName() {
    const signers = this.data.opinions.signersName || [];
    this.setData({
      signersStr: signers.join(',') // 将数组转换为顿号分隔的字符串
    });
  },

  getProposalDetail(id) {
    const app = getApp();
    return app.civilApi.civilDetail(id)
      .then(res => {
        console.log('res.data:', res.data); // 添加调试信息
        return res.data.data || {}; // 避免返回 null，可设为空对象
      })
      .catch(error => {
        console.error('请求失败', error);
        throw error;
      })
  },
  downloadFile(e) {
    const url = e.currentTarget.dataset.url;
    const fileName = e.currentTarget.dataset.name;

    console.log('开始下载文件:', fileName, url);

    // 显示下载中提示
    wx.showLoading({
      title: '下载中...',
    });

    // 获取正确的文件扩展名
    const fileExt = fileName.substring(fileName.lastIndexOf('.') + 1).toLowerCase();
    console.log('文件扩展名:', fileExt);

    // 检查文件类型是否支持
    const documentTypes = ['doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'pdf', 'txt'];
    const imageTypes = ['jpg', 'jpeg', 'png', 'gif', 'webp'];

    wx.downloadFile({
      url: url,
      success: (res) => {
        console.log('下载结果:', res);
        wx.hideLoading();

        if (res.statusCode === 200) {
          const filePath = res.tempFilePath;
          console.log('临时文件路径:', filePath);

          // 创建新的临时文件路径，确保扩展名正确
          const newFilePath = `${wx.env.USER_DATA_PATH}/${new Date().getTime()}.${fileExt}`;

          // 复制文件到新路径，确保扩展名正确
          wx.getFileSystemManager().copyFileSync(filePath, newFilePath);
          console.log('新文件路径:', newFilePath);

          // 根据文件类型选择不同的打开方式
          if (imageTypes.includes(fileExt)) {
            // 图片文件使用预览图片
            wx.previewImage({
              urls: [newFilePath],
              success: () => {
                console.log('预览图片成功');
              },
              fail: (error) => {
                console.error('预览图片失败', error);
                wx.showModal({
                  title: '提示',
                  content: '无法预览此图片，请在其他设备上查看',
                  showCancel: false
                });
              }
            });
          } else if (documentTypes.includes(fileExt)) {
            // 文档文件使用打开文档
            wx.openDocument({
              filePath: newFilePath,
              fileType: fileExt,
              showMenu: true,
              success: () => {
                console.log('打开文档成功');
              },
              fail: (error) => {
                console.error('打开文件失败', error);

                // 尝试不指定fileType打开
                wx.openDocument({
                  filePath: newFilePath,
                  showMenu: true,
                  success: () => {
                    console.log('第二次尝试打开文档成功');
                  },
                  fail: (error2) => {
                    console.error('第二次尝试打开文件失败', error2);

                    // 提供复制链接选项
                    wx.showModal({
                      title: '无法打开文件',
                      content: '该文件无法在小程序中打开，是否复制链接在浏览器中查看？',
                      confirmText: '复制链接',
                      success: (res) => {
                        if (res.confirm) {
                          wx.setClipboardData({
                            data: url,
                            success: () => {
                              wx.showToast({
                                title: '链接已复制',
                                icon: 'success'
                              });
                            }
                          });
                        }
                      }
                    });
                  }
                });
              }
            });
          } else {
            // 不支持的文件类型
            wx.showModal({
              title: '提示',
              content: '该文件类型暂不支持在小程序中打开，是否复制链接在浏览器中查看？',
              confirmText: '复制链接',
              success: (res) => {
                if (res.confirm) {
                  wx.setClipboardData({
                    data: url,
                    success: () => {
                      wx.showToast({
                        title: '链接已复制',
                        icon: 'success'
                      });
                    }
                  });
                }
              }
            });
          }
        } else {
          wx.showModal({
            title: '下载失败',
            content: '文件下载失败，状态码: ' + res.statusCode,
            showCancel: false
          });
        }
      },
      fail: (error) => {
        wx.hideLoading();
        console.error('下载失败', error);

        wx.showModal({
          title: '下载失败',
          content: '文件下载失败，请检查网络连接',
          showCancel: false
        });
      }
    });
  },
  // 下载所有文件
  downloadAllFiles: function (e) {
    const files = e.currentTarget.dataset.files || [];
    const content = e.currentTarget.dataset.content || '';

    wx.showLoading({
      title: '准备下载...'
    });
    // 准备下载队列
    let downloadQueue = [];

    // 从后端获取Word文档
    this.downloadProposalWord().then(wordFile => {
      console.log('Word文档获取结果:', wordFile ? '成功' : '失败');

      if (wordFile) {
        downloadQueue.push(wordFile);

        // 添加附件到下载队列
        if (files && files.length > 0) {
          downloadQueue = downloadQueue.concat(files.map(file => ({
            isContent: false,
            url: file.url,
            name: file.name,
            size: file.size
          })));
        }
        // 开始下载
        this.processDownloadQueue(downloadQueue, []);
      } else {
        wx.hideLoading();
        wx.showToast({
          title: '获取文档失败',
          icon: 'none'
        });
      }
    }).catch(error => {
      wx.hideLoading();
      console.error('获取Word文档失败', error);
      wx.showToast({
        title: '获取文档失败',
        icon: 'none'
      });
    });
  },

  // 从后端获取Word文档
  downloadProposalWord: function () {
    const app = getApp();
    const opinions = this.data.opinions.opinionId;

    return new Promise((resolve, reject) => {
      wx.showLoading({
        title: '获取文档...'
      });

      // 添加调试信息
      console.log('开始请求Word文档，提案ID:', proposalId);
      console.log('请求URL:', `${app.globalData.baseUrl}/users/publicOpinions/wordCreate/${opinions}`);
      console.log('Token:', app.globalData.token || wx.getStorageSync('token') || '无token');

      // 先使用POST请求获取文件URL
      wx.request({
        url: `${app.globalData.baseUrl}/users/publicOpinions/wordCreate/${opinions.opinionId}`,
        method: 'POST',
        header: {
          'Authorization': `Bearer ${app.globalData.token || wx.getStorageSync('token')}`,
          'Content-Type': 'application/json'
        },
        responseType: 'arraybuffer',  // 直接获取二进制数据
        success: (res) => {
          console.log('Word文档请求响应状态码:', res.statusCode);
          console.log('响应头:', res.header);

          if (res.statusCode === 200) {
            // 检查响应数据是否为空
            if (!res.data || res.data.byteLength === 0) {
              console.error('响应数据为空');
              wx.hideLoading();
              resolve(null);
              return;
            }

            console.log('响应数据大小:', res.data.byteLength, '字节');

            // 将二进制数据写入临时文件
            const fs = wx.getFileSystemManager();
            const tempFilePath = `${wx.env.USER_DATA_PATH}/temp_${new Date().getTime()}.docx`;

            try {
              fs.writeFileSync(
                tempFilePath,
                res.data,
                'binary'
              );

              console.log('文件保存成功:', tempFilePath);
              wx.hideLoading();

              // 文件保存成功
              resolve({
                isContent: false,
                isWordDoc: true,
                path: tempFilePath,
                name: `报送详情_${proposalId}.docx`,
                type: 'docx'
              });
            } catch (error) {
              console.error('保存文件失败', error);
              wx.hideLoading();
              resolve(null);
            }
          } else {
            console.error('获取Word文档失败', res);
            wx.hideLoading();

            // 尝试解析错误信息
            let errorMsg = '未知错误';
            try {
              if (typeof res.data === 'string') {
                errorMsg = res.data;
              } else {
                // 尝试将二进制数据转为字符串
                const decoder = new TextDecoder('utf-8');
                errorMsg = decoder.decode(res.data);
              }
              console.error('错误信息:', errorMsg);
            } catch (e) {
              console.error('解析错误信息失败', e);
            }

            resolve(null);
          }
        },
        fail: (error) => {
          wx.hideLoading();
          console.error('请求Word文档失败', error);
          resolve(null);
        }
      });
    });
  },
  // 处理下载队列
  processDownloadQueue: function (queue, savedFiles) {
    if (queue.length === 0) {
      // 所有文件处理完成
      wx.hideLoading();
      if (savedFiles.length > 0) {
        // 保存到缓存
        wx.setStorageSync(`downloaded_files_civil_${this.data.opinions.opinionId}`, savedFiles);

        // 更新按钮状态，但不自动跳转
        this.setData({
          downloadedFiles: savedFiles
        });

        wx.showToast({
          title: '下载完成',
          icon: 'success'
        });
      }
      return;
    }

    const currentFile = queue[0];
    const remainingQueue = queue.slice(1);

    if (currentFile.isContent) {
      // 保存文本内容
      try {
        const filePath = `${wx.env.USER_DATA_PATH}/${currentFile.name}`;
        wx.getFileSystemManager().writeFileSync(
          filePath,
          currentFile.content,
          'utf8'
        );

        // 使用文件路径而不是内容进行上传
        const app = getApp();
        app.userRequest.uploadFiles(filePath, {
          "filename": currentFile.name
        }).then(
          res => {
            savedFiles.push({
              path: filePath,
              name: currentFile.name,
              type: 'docx',
              url: res.data.data
            });
            this.processDownloadQueue(remainingQueue, savedFiles);
          }
        ).catch(err => {
          console.error('上传文件失败', err);
          // 即使上传失败，也将文件添加到列表中，只是没有URL
          savedFiles.push({
            path: filePath,
            name: currentFile.name,
            type: 'txt',
            url: null
          });
          this.processDownloadQueue(remainingQueue, savedFiles);
        });
      } catch (err) {
        console.error('保存内容失败', err);
        this.processDownloadQueue(remainingQueue, savedFiles);
      }
    } else if (currentFile.isWordDoc) {
      // 处理Word文档，这种情况下已经有本地文件路径，需要上传到后端获取URL
      try {
        // 使用文件路径上传到后端
        const app = getApp();
        app.userRequest.uploadFiles(currentFile.path, {
          "filename": currentFile.name
        }).then(
          res => {
            savedFiles.push({
              path: currentFile.path,
              name: currentFile.name,
              type: currentFile.type,
              size: currentFile.size || 0,
              url: res.data.data // 保存后端返回的URL
            });
            console.log('Word文档上传成功，URL:', res.data.data);
            this.processDownloadQueue(remainingQueue, savedFiles);
          }
        ).catch(err => {
          console.error('上传Word文档失败', err);
          // 即使上传失败，也将文件添加到列表中，只是没有URL
          savedFiles.push({
            path: currentFile.path,
            name: currentFile.name,
            type: currentFile.type,
            size: currentFile.size || 0,
            url: null
          });
          this.processDownloadQueue(remainingQueue, savedFiles);
        });
      } catch (err) {
        console.error('处理Word文档失败', err);
        // 出错时也添加到列表，但没有URL
        savedFiles.push({
          path: currentFile.path,
          name: currentFile.name,
          type: currentFile.type,
          size: currentFile.size || 0
        });
        this.processDownloadQueue(remainingQueue, savedFiles);
      }
    } else {
      // 下载附件
      if (!currentFile.url) {
        console.error('文件URL为空:', currentFile);
        this.processDownloadQueue(remainingQueue, savedFiles);
        return;
      }

      wx.downloadFile({
        url: currentFile.url,
        success: (res) => {
          if (res.statusCode === 200) {
            // 获取文件扩展名
            const ext = currentFile.url.substring(currentFile.url.lastIndexOf('.') + 1).toLowerCase();

            // 保存到本地存储
            try {
              const filePath = `${wx.env.USER_DATA_PATH}/${currentFile.name}.${ext}`;
              wx.getFileSystemManager().saveFileSync(res.tempFilePath, filePath);

              savedFiles.push({
                path: filePath,
                name: currentFile.name,
                type: ext,
                size: currentFile.size,
                url: currentFile.url // 保存原始URL
              });
            } catch (err) {
              console.error('保存文件失败', err);
              // 如果保存失败，使用临时路径
              savedFiles.push({
                path: res.tempFilePath,
                name: currentFile.name,
                type: ext,
                size: currentFile.size,
                url: currentFile.url // 保存原始URL
              });
            }
          }
          this.processDownloadQueue(remainingQueue, savedFiles);
        },
        fail: (err) => {
          console.error('下载文件失败', err);
          this.processDownloadQueue(remainingQueue, savedFiles);
        }
      });
    }
  },
  // 从后端获取Word文档
  downloadProposalWord: function () {
    const app = getApp();
    const opinions = this.data.opinions.opinionId;

    return new Promise((resolve, reject) => {
      wx.showLoading({
        title: '获取文档...'
      });


      const token = wx.getStorageSync('token') || null;
      // 先使用POST请求获取文件URL
      wx.request({
        url: `${app.globalData.baseUrl}/users/publicOpinions/wordCreate/${opinions}`,
        method: 'POST',
        header: {
          'Authorization': token,
          'Content-Type': 'application/json'
        },
        responseType: 'arraybuffer',  // 直接获取二进制数据
        success: (res) => {
          console.log('Word文档请求响应状态码:', res.statusCode);

          if (res.statusCode === 200) {
            // 检查响应数据是否为空
            if (!res.data || res.data.byteLength === 0) {
              console.error('响应数据为空');
              wx.hideLoading();
              resolve(null);
              return;
            }

            // 将二进制数据写入临时文件
            const fs = wx.getFileSystemManager();
            const tempFilePath = `${wx.env.USER_DATA_PATH}/temp_${new Date().getTime()}.docx`;

            try {
              fs.writeFileSync(
                tempFilePath,
                res.data,
                'binary'
              );

              console.log('文件保存成功:', tempFilePath);
              wx.hideLoading();

              // 文件保存成功
              resolve({
                isContent: false,
                isWordDoc: true,
                path: tempFilePath,
                name: `报送详情_${this.data.opinions.opinionId}.docx`,
                type: 'docx'
              });
            } catch (error) {
              console.error('保存文件失败', error);
              wx.hideLoading();
              resolve(null);
            }
          } else {
            console.error('获取Word文档失败', res);
            wx.hideLoading();

            // 尝试解析错误信息
            let errorMsg = '未知错误';
            try {
              if (typeof res.data === 'string') {
                errorMsg = res.data;
              } else {
                // 尝试将二进制数据转为字符串
                const decoder = new TextDecoder('utf-8');
                errorMsg = decoder.decode(res.data);
              }
              console.error('错误信息:', errorMsg);
            } catch (e) {
              console.error('解析错误信息失败', e);
            }

            resolve(null);
          }
        },
        fail: (error) => {
          wx.hideLoading();
          console.error('请求Word文档失败', error);
          resolve(null);
        }
      });
    });
  },
  // 跳转到文件列表页面
  goToFileList: function () {
    wx.navigateTo({
      url: `/pages/files/fileList?pid=downloaded_files_civil_${this.data.opinions.opinionId}`
    });
  },
  // 验证缓存的文件是否仍然存在
  validateCachedFiles: function (cachedFiles, opinionId) {
    const fs = wx.getFileSystemManager();
    const validFiles = [];

    for (const file of cachedFiles) {
      try {
        fs.accessSync(file.path);
        validFiles.push(file);
      } catch (e) {
        // 文件不存在，跳过
        console.log('文件不存在:', file.path);
      }
    }

    if (validFiles.length > 0) {
      // 如果有有效文件，更新状态
      this.setData({
        downloadedFiles: validFiles
      });
      // 更新缓存
      wx.setStorageSync(`downloaded_files_civil_${opinionId}`, validFiles);
    } else {
      // 如果没有有效文件，清除缓存
      wx.removeStorageSync(`downloaded_files_civil_${opinionId}`);
    }
  },
  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    const id = this.data.opinions.opinionId;
    this.getProposalDetail(id).then(res => {
      this.setData({
        opinions: res
      })
      this.processSignersName();
    })
    setTimeout(() => {
      wx.stopPullDownRefresh()
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1000
      })
    }, 1000)
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  // 打开弹出层
  showFullContent() {
    this.setData({
      showFullContent: true
    });
  },

  // 打开弹出层
  showResultContent() {
    this.setData({
      showResultContent: true
    });
  },

  // 关闭弹出层
  closePopup() {
    this.setData({
      showFullContent: false
    });
  },
  // 关闭弹出层
  closeResultPopup() {
    this.setData({
      showResultContent: false
    });
  },

  // 阻止冒泡
  stopPropagation(e) {
    e.stopPropagation();
  },
})